{"cells":[{"cell_type":"markdown","metadata":{"graffitiCellId":"id_on4eyh2","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"9E73B21214794A1B8F92AF2169A6F409","mdEditEnable":false},"source":"# 文本情感分类\n\n文本分类是自然语言处理的一个常见任务，它把一段不定长的文本序列变换为文本的类别。本节关注它的一个子问题：使用文本情感分类来分析文本作者的情绪。这个问题也叫情感分析，并有着广泛的应用。\n\n同搜索近义词和类比词一样，文本分类也属于词嵌入的下游应用。在本节中，我们将应用预训练的词向量和含多个隐藏层的双向循环神经网络与卷积神经网络，来判断一段不定长的文本序列中包含的是正面还是负面的情绪。后续内容将从以下几个方面展开：\n\n1. 文本情感分类数据集\n2. 使用循环神经网络进行情感分类\n3. 使用卷积神经网络进行情感分类"},{"cell_type":"code","execution_count":4,"metadata":{"graffitiCellId":"id_qpkl0v3","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"4C34DE8574664EBC876799AFFD97FACC","collapsed":false,"scrolled":false},"outputs":[],"source":"import collections\nimport os\nimport random\nimport time\nfrom tqdm import tqdm\nimport torch\nfrom torch import nn\nimport torchtext.vocab as Vocab\nimport torch.utils.data as Data\nimport torch.nn.functional as F\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_75c1s0z","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"ECA9EC64CB6B4C0C8CCDB65ACD18D2BE","mdEditEnable":false},"source":"## 文本情感分类数据\n\n我们使用[斯坦福的IMDb数据集（Stanford’s Large Movie Review Dataset）](http://ai.stanford.edu/~amaas/data/sentiment/)作为文本情感分类的数据集。\n\n### 读取数据\n\n数据集文件夹结构：\n\n```\n| aclImdb_v1\n    | train\n    |   | pos\n    |   |   | 0_9.txt  \n    |   |   | 1_7.txt\n    |   |   | ...\n    |   | neg\n    |   |   | 0_3.txt\n    |   |   | 1_1.txt\n    |   | ...\n    | test\n    |   | pos\n    |   | neg\n    |   | ...\n    | ...\n```"},{"cell_type":"code","execution_count":5,"metadata":{"graffitiCellId":"id_nxrjw92","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"2D650272040243AA8AC04AA8BCC96645","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"100%|██████████| 12500/12500 [00:00<00:00, 15484.71it/s]\n100%|██████████| 12500/12500 [00:00<00:00, 53658.60it/s]\n100%|██████████| 12500/12500 [00:00<00:00, 53187.52it/s]\n100%|██████████| 12500/12500 [00:00<00:00, 52966.52it/s]","name":"stderr"},{"output_type":"stream","text":"1 \t i'm 60 years old, a guitarist, (lead/rhythm), and \n0 \t it's the worst movie i've ever seen. the action is\n1 \t i have seen the movie holes and say that it has to\n1 \t i just saw this last night, it was broadcast on th\n0 \t ...well, pop this into the dvd, waste an hour and \n","name":"stdout"},{"output_type":"stream","text":"\n","name":"stderr"}],"source":"def read_imdb(folder='train', data_root=\"/home/kesci/input/IMDB2578/aclImdb_v1/aclImdb\"):\n    data = []\n    for label in ['pos', 'neg']:\n        folder_name = os.path.join(data_root, folder, label)\n        for file in tqdm(os.listdir(folder_name)):\n            with open(os.path.join(folder_name, file), 'rb') as f:\n                review = f.read().decode('utf-8').replace('\\n', '').lower()\n                data.append([review, 1 if label == 'pos' else 0])\n    random.shuffle(data)\n    return data\n\nDATA_ROOT = \"/home/kesci/input/IMDB2578/aclImdb_v1/\"\ndata_root = os.path.join(DATA_ROOT, \"aclImdb\")\ntrain_data, test_data = read_imdb('train', data_root), read_imdb('test', data_root)\n\n# 打印训练数据中的前五个sample\nfor sample in train_data[:5]:\n    print(sample[1], '\\t', sample[0][:50])"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_q12pdj4","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"27D596E884AD48778032BE5876EA56C7","mdEditEnable":false},"source":"### 预处理数据\n\n读取数据后，我们先根据文本的格式进行单词的切分，再利用 [`torchtext.vocab.Vocab`](https://torchtext.readthedocs.io/en/latest/vocab.html#vocab) 创建词典。"},{"cell_type":"code","execution_count":6,"metadata":{"graffitiCellId":"id_f6u98c3","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"501A5FC9F17D49B084DE9C15B04233A3","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"# words in vocab: 46152\n","name":"stdout"}],"source":"def get_tokenized_imdb(data):\n    '''\n    @params:\n        data: 数据的列表，列表中的每个元素为 [文本字符串，0/1标签] 二元组\n    @return: 切分词后的文本的列表，列表中的每个元素为切分后的词序列\n    '''\n    def tokenizer(text):\n        return [tok.lower() for tok in text.split(' ')]\n    \n    return [tokenizer(review) for review, _ in data]\n\ndef get_vocab_imdb(data):\n    '''\n    @params:\n        data: 同上\n    @return: 数据集上的词典，Vocab 的实例（freqs, stoi, itos）\n    '''\n    tokenized_data = get_tokenized_imdb(data)\n    counter = collections.Counter([tk for st in tokenized_data for tk in st])\n    return Vocab.Vocab(counter, min_freq=5)\n\nvocab = get_vocab_imdb(train_data)\nprint('# words in vocab:', len(vocab))"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_9s26xhr","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"B6CDF2CC978D48F980E835392BAC8CF0","mdEditEnable":false},"source":"词典和词语的索引创建好后，就可以将数据集的文本从字符串的形式转换为单词下标序列的形式，以待之后的使用。"},{"cell_type":"code","execution_count":7,"metadata":{"graffitiCellId":"id_3ejykvx","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"B8BDA6B5EE364F538022F97E8A1114FC","collapsed":false,"scrolled":false},"outputs":[],"source":"def preprocess_imdb(data, vocab):\n    '''\n    @params:\n        data: 同上，原始的读入数据\n        vocab: 训练集上生成的词典\n    @return:\n        features: 单词下标序列，形状为 (n, max_l) 的整数张量\n        labels: 情感标签，形状为 (n,) 的0/1整数张量\n    '''\n    max_l = 500  # 将每条评论通过截断或者补0，使得长度变成500\n\n    def pad(x):\n        return x[:max_l] if len(x) > max_l else x + [0] * (max_l - len(x))\n\n    tokenized_data = get_tokenized_imdb(data)\n    features = torch.tensor([pad([vocab.stoi[word] for word in words]) for words in tokenized_data])\n    labels = torch.tensor([score for _, score in data])\n    return features, labels"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_yge4ncq","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"D4189672985F4DA781725897C3395EBB","mdEditEnable":false},"source":"### 创建数据迭代器\n\n利用 [`torch.utils.data.TensorDataset`](https://pytorch.org/docs/stable/data.html?highlight=tensor%20dataset#torch.utils.data.TensorDataset)，可以创建 PyTorch 格式的数据集，从而创建数据迭代器。"},{"cell_type":"code","execution_count":6,"metadata":{"graffitiCellId":"id_q2o053r","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"46970B8D972042009CC3393C59BCD4B6","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"X torch.Size([64, 500]) y torch.Size([64])\n#batches: 391\n","name":"stdout"}],"source":"train_set = Data.TensorDataset(*preprocess_imdb(train_data, vocab))\ntest_set = Data.TensorDataset(*preprocess_imdb(test_data, vocab))\n\n# 上面的代码等价于下面的注释代码\n# train_features, train_labels = preprocess_imdb(train_data, vocab)\n# test_features, test_labels = preprocess_imdb(test_data, vocab)\n# train_set = Data.TensorDataset(train_features, train_labels)\n# test_set = Data.TensorDataset(test_features, test_labels)\n\n# len(train_set) = features.shape[0] or labels.shape[0]\n# train_set[index] = (features[index], labels[index])\n\nbatch_size = 64\ntrain_iter = Data.DataLoader(train_set, batch_size, shuffle=True)\ntest_iter = Data.DataLoader(test_set, batch_size)\n\nfor X, y in train_iter:\n    print('X', X.shape, 'y', y.shape)\n    break\nprint('#batches:', len(train_iter))"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_uu3a646","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"E5DAD388C64B49FF86DA61D202D5A104","mdEditEnable":false},"source":"## 使用循环神经网络\n\n### 双向循环神经网络\n\n在[“双向循环神经网络”](https://zh.d2l.ai/chapter_recurrent-neural-networks/bi-rnn.html)一节中，我们介绍了其模型与前向计算的公式，这里简单回顾一下：\n\n![Image Name](https://cdn.kesci.com/upload/image/q5mnobct47.png?imageView2/0/w/960/h/960)\n\n\n![Image Name](https://cdn.kesci.com/upload/image/q5mo6okdnp.png?imageView2/0/w/960/h/960)\n\n\n给定输入序列 $\\{\\boldsymbol{X}_1,\\boldsymbol{X}_2,\\dots,\\boldsymbol{X}_T\\}$，其中 $\\boldsymbol{X}_t\\in\\mathbb{R}^{n\\times d}$ 为时间步（批量大小为 $n$，输入维度为 $d$）。在双向循环神经网络的架构中，设时间步 $t$ 上的正向隐藏状态为 $\\overrightarrow{\\boldsymbol{H}}_{t} \\in \\mathbb{R}^{n \\times h}$ （正向隐藏状态维度为 $h$），反向隐藏状态为 $\\overleftarrow{\\boldsymbol{H}}_{t} \\in \\mathbb{R}^{n \\times h}$ （反向隐藏状态维度为 $h$）。我们可以分别计算正向隐藏状态和反向隐藏状态：\n\n\n$$\n\n\\begin{aligned}\n&\\overrightarrow{\\boldsymbol{H}}_{t}=\\phi\\left(\\boldsymbol{X}_{t} \\boldsymbol{W}_{x h}^{(f)}+\\overrightarrow{\\boldsymbol{H}}_{t-1} \\boldsymbol{W}_{h h}^{(f)}+\\boldsymbol{b}_{h}^{(f)}\\right)\\\\\n&\\overleftarrow{\\boldsymbol{H}}_{t}=\\phi\\left(\\boldsymbol{X}_{t} \\boldsymbol{W}_{x h}^{(b)}+\\overleftarrow{\\boldsymbol{H}}_{t+1} \\boldsymbol{W}_{h h}^{(b)}+\\boldsymbol{b}_{h}^{(b)}\\right)\n\\end{aligned}\n\n$$\n\n\n其中权重 $\\boldsymbol{W}_{x h}^{(f)} \\in \\mathbb{R}^{d \\times h}, \\boldsymbol{W}_{h h}^{(f)} \\in \\mathbb{R}^{h \\times h}, \\boldsymbol{W}_{x h}^{(b)} \\in \\mathbb{R}^{d \\times h}, \\boldsymbol{W}_{h h}^{(b)} \\in \\mathbb{R}^{h \\times h}$ 和偏差 $\\boldsymbol{b}_{h}^{(f)} \\in \\mathbb{R}^{1 \\times h}, \\boldsymbol{b}_{h}^{(b)} \\in \\mathbb{R}^{1 \\times h}$ 均为模型参数，$\\phi$ 为隐藏层激活函数。\n\n对于每个方向的每个隐藏状态，计算它时都会用到该方向中上一步的隐藏状态，所以双向循环神经网络中的隐藏状态不能被并行地算出.\n\n然后我们连结两个方向的隐藏状态 $\\overrightarrow{\\boldsymbol{H}}_{t}$ 和 $\\overleftarrow{\\boldsymbol{H}}_{t}$ 来得到隐藏状态 $\\boldsymbol{H}_{t} \\in \\mathbb{R}^{n \\times 2 h}$，并将其输入到输出层。输出层计算输出 $\\boldsymbol{O}_{t} \\in \\mathbb{R}^{n \\times q}$（输出维度为 $q$）：\n\n\n$$\n\n\\boldsymbol{O}_{t}=\\boldsymbol{H}_{t} \\boldsymbol{W}_{h q}+\\boldsymbol{b}_{q}\n\n$$\n\n\n其中权重 $\\boldsymbol{W}_{h q} \\in \\mathbb{R}^{2 h \\times q}$ 和偏差 $\\boldsymbol{b}_{q} \\in \\mathbb{R}^{1 \\times q}$ 为输出层的模型参数。不同方向上的隐藏单元维度也可以不同。\n\n利用 [`torch.nn.RNN`](https://pytorch.org/docs/stable/nn.html?highlight=rnn#torch.nn.RNN) 或 [`torch.nn.LSTM`](https://pytorch.org/docs/stable/nn.html?highlight=lstm#torch.nn.LSTM) 模组，我们可以很方便地实现双向循环神经网络，下面是以 LSTM 为例的代码。"},{"cell_type":"code","execution_count":7,"metadata":{"graffitiCellId":"id_put7k6i","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"3F85195C090D49B8A78A951C4CD7076B","collapsed":false,"scrolled":false},"outputs":[],"source":"class BiRNN(nn.Module):\n    def __init__(self, vocab, embed_size, num_hiddens, num_layers):\n        '''\n        @params:\n            vocab: 在数据集上创建的词典，用于获取词典大小\n            embed_size: 嵌入维度大小\n            num_hiddens: 隐藏状态维度大小\n            num_layers: 隐藏层个数\n        '''\n        super(BiRNN, self).__init__()\n        self.embedding = nn.Embedding(len(vocab), embed_size)\n        \n        # encoder-decoder framework\n        # bidirectional设为True即得到双向循环神经网络\n        self.encoder = nn.LSTM(input_size=embed_size, \n                                hidden_size=num_hiddens, \n                                num_layers=num_layers,\n                                bidirectional=True)\n        self.decoder = nn.Linear(4*num_hiddens, 2) # 初始时间步和最终时间步的隐藏状态作为全连接层输入\n        \n    def forward(self, inputs):\n        '''\n        @params:\n            inputs: 词语下标序列，形状为 (batch_size, seq_len) 的整数张量\n        @return:\n            outs: 对文本情感的预测，形状为 (batch_size, 2) 的张量\n        '''\n        # 因为LSTM需要将序列长度(seq_len)作为第一维，所以需要将输入转置\n        embeddings = self.embedding(inputs.permute(1, 0)) # (seq_len, batch_size, d)\n        # rnn.LSTM 返回输出、隐藏状态和记忆单元，格式如 outputs, (h, c)\n        outputs, _ = self.encoder(embeddings) # (seq_len, batch_size, 2*h)\n        encoding = torch.cat((outputs[0], outputs[-1]), -1) # (batch_size, 4*h)\n        outs = self.decoder(encoding) # (batch_size, 2)\n        return outs\n\nembed_size, num_hiddens, num_layers = 100, 100, 2\nnet = BiRNN(vocab, embed_size, num_hiddens, num_layers)"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_ksnuxvt","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"331B28609E2F4FCD81A30F5E665DB7EF","mdEditEnable":false},"source":"### 加载预训练的词向量\n\n由于预训练词向量的词典及词语索引与我们使用的数据集并不相同，所以需要根据目前的词典及索引的顺序来加载预训练词向量。"},{"cell_type":"code","execution_count":12,"metadata":{"graffitiCellId":"id_1x32tei","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"E1E904AB724240589BAF01DA77485092","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":" 99%|█████████▉| 397764/400000 [00:15<00:00, 27536.08it/s]","name":"stderr"},{"output_type":"stream","text":"There are 21202 oov words.\n","name":"stdout"},{"output_type":"stream","text":"\r 99%|█████████▉| 397764/400000 [00:30<00:00, 27536.08it/s]","name":"stderr"}],"source":"cache_dir = \"/home/kesci/input/GloVe6B5429\"\nglove_vocab = Vocab.GloVe(name='6B', dim=100, cache=cache_dir)\n\ndef load_pretrained_embedding(words, pretrained_vocab):\n    '''\n    @params:\n        words: 需要加载词向量的词语列表，以 itos (index to string) 的词典形式给出\n        pretrained_vocab: 预训练词向量\n    @return:\n        embed: 加载到的词向量\n    '''\n    embed = torch.zeros(len(words), pretrained_vocab.vectors[0].shape[0]) # 初始化为0\n    oov_count = 0 # out of vocabulary\n    for i, word in enumerate(words):\n        try:\n            idx = pretrained_vocab.stoi[word]\n            embed[i, :] = pretrained_vocab.vectors[idx]\n        except KeyError:\n            oov_count += 1\n    if oov_count > 0:\n        print(\"There are %d oov words.\" % oov_count)\n    return embed\n\nnet.embedding.weight.data.copy_(load_pretrained_embedding(vocab.itos, glove_vocab))\nnet.embedding.weight.requires_grad = False # 直接加载预训练好的, 所以不需要更新它"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_rfun1jp","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"6C1065F141F041D68C843ECD13DB5193","mdEditEnable":false},"source":"### 训练模型\n\n训练时可以调用之前编写的 `train` 及 `evaluate_accuracy` 函数。"},{"cell_type":"code","execution_count":13,"metadata":{"graffitiCellId":"id_jv4ye1d","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"6E7F2873372E42F0AD93F544A6DEEBDC","collapsed":false,"scrolled":false},"outputs":[],"source":"def evaluate_accuracy(data_iter, net, device=None):\n    if device is None and isinstance(net, torch.nn.Module):\n        device = list(net.parameters())[0].device \n    acc_sum, n = 0.0, 0\n    with torch.no_grad():\n        for X, y in data_iter:\n            if isinstance(net, torch.nn.Module):\n                net.eval()\n                acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()\n                net.train()\n            else:\n                if('is_training' in net.__code__.co_varnames):\n                    acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item() \n                else:\n                    acc_sum += (net(X).argmax(dim=1) == y).float().sum().item() \n            n += y.shape[0]\n    return acc_sum / n\n\ndef train(train_iter, test_iter, net, loss, optimizer, device, num_epochs):\n    net = net.to(device)\n    print(\"training on \", device)\n    batch_count = 0\n    for epoch in range(num_epochs):\n        train_l_sum, train_acc_sum, n, start = 0.0, 0.0, 0, time.time()\n        for X, y in train_iter:\n            X = X.to(device)\n            y = y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y) \n            optimizer.zero_grad()\n            l.backward()\n            #PyTorch 的嵌入层在进行前向传播时，其输入张量需要为 torch.long 格式\n            optimizer.step()\n            train_l_sum += l.cpu().item()\n            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()\n            n += y.shape[0]\n            batch_count += 1\n        test_acc = evaluate_accuracy(test_iter, net)\n        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'\n              % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_jt55knm","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"3E29E40F14214A51B947A99BACBA7094","mdEditEnable":false},"source":"由于嵌入层的参数是不需要在训练过程中被更新的，所以我们利用 `filter` 函数和 `lambda` 表达式来过滤掉模型中不需要更新参数的部分。"},{"cell_type":"code","execution_count":25,"metadata":{"graffitiCellId":"id_qx54klj","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"AB49B88221294D6283A876AFA0A6700C","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"training on  cpu\nepoch 1, loss 0.9336, train acc 0.658, test acc 0.788, time 361.3 sec\nepoch 2, loss 0.2986, train acc 0.811, test acc 0.744, time 364.4 sec\nepoch 3, loss 0.1692, train acc 0.879, test acc 0.791, time 353.2 sec\nepoch 4, loss 0.1331, train acc 0.910, test acc 0.782, time 361.1 sec\nepoch 5, loss 0.1177, train acc 0.918, test acc 0.771, time 366.7 sec\n","name":"stdout"}],"source":"lr, num_epochs = 0.01, 5\noptimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), lr=lr)\nloss = nn.CrossEntropyLoss()\n\ntrain(train_iter, test_iter, net, loss, optimizer, device, num_epochs)"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_yb7fec7","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"AA2AF53E215F4550ABB1903215DE743D","mdEditEnable":false},"source":"```\ntraining on  cuda\n100%|█████████▉| 398892/400000 [00:40<00:00, 18148.73it/s]\nepoch 1, loss 0.6206, train acc 0.631, test acc 0.798, time 41.7 sec\nepoch 2, loss 0.2079, train acc 0.813, test acc 0.819, time 42.1 sec\nepoch 3, loss 0.1186, train acc 0.843, test acc 0.847, time 40.8 sec\nepoch 4, loss 0.0777, train acc 0.869, test acc 0.854, time 41.2 sec\nepoch 5, loss 0.0544, train acc 0.887, test acc 0.861, time 41.8 sec\n```\n\n*注：由于本地CPU上训练时间过长，故只截取了运行的结果，后同。大家可以自行在网站上训练。*"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_mxbji9v","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"E92D6D9EC8D84D998AFF2BC517515378","mdEditEnable":false},"source":"### 评价模型"},{"cell_type":"code","execution_count":15,"metadata":{"graffitiCellId":"id_rtedxzv","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"61A4F01E8A0C434CB6A193D540C58366","collapsed":false,"scrolled":false},"outputs":[{"output_type":"execute_result","metadata":{},"data":{"text/plain":"'positive'"},"transient":{},"execution_count":15}],"source":"def predict_sentiment(net, vocab, sentence):\n    '''\n    @params：\n        net: 训练好的模型\n        vocab: 在该数据集上创建的词典，用于将给定的单词序转换为单词下标的序列，从而输入模型\n        sentence: 需要分析情感的文本，以单词序列的形式给出\n    @return: 预测的结果，positive 为正面情绪文本，negative 为负面情绪文本\n    '''\n    device = list(net.parameters())[0].device # 读取模型所在的环境\n    sentence = torch.tensor([vocab.stoi[word] for word in sentence], device=device)\n    label = torch.argmax(net(sentence.view((1, -1))), dim=1)\n    return 'positive' if label.item() == 1 else 'negative'\n\npredict_sentiment(net, vocab, ['this', 'movie', 'is', 'so', 'great'])"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_pgdgkpy","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"7AD2D848F45E4FCE8BD2E960F1ECCCC6","mdEditEnable":false},"source":"```\n'positive'\n```"},{"cell_type":"code","execution_count":16,"metadata":{"graffitiCellId":"id_ci26bbu","scrolled":false,"jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"F1AF9815A91C45C4B87B5641F632C949","collapsed":false},"outputs":[{"output_type":"execute_result","metadata":{},"data":{"text/plain":"'positive'"},"transient":{},"execution_count":16}],"source":"predict_sentiment(net, vocab, ['this', 'movie', 'is', 'so', 'bad'])"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_aaiy2s0","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"D4C7F9B7B65D4BA8803098586182B437","mdEditEnable":false},"source":"```\n'negative'\n```"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_h9301aq","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"467567D6536D47B887CF000BF0B9E7B1","mdEditEnable":false},"source":"## 使用卷积神经网络\n\n### 一维卷积层\n\n在介绍模型前我们先来解释一维卷积层的工作原理。与二维卷积层一样，一维卷积层使用一维的互相关运算。在一维互相关运算中，卷积窗口从输入数组的最左方开始，按从左往右的顺序，依次在输入数组上滑动。当卷积窗口滑动到某一位置时，窗口中的输入子数组与核数组按元素相乘并求和，得到输出数组中相应位置的元素。如图所示，输入是一个宽为 7 的一维数组，核数组的宽为 2。可以看到输出的宽度为 7−2+1=6，且第一个元素是由输入的最左边的宽为 2 的子数组与核数组按元素相乘后再相加得到的：0×1+1×2=2。\n\n![Image Name](https://cdn.kesci.com/upload/image/q5mo8qs7dc.png?imageView2/0/w/960/h/960)\n"},{"cell_type":"code","execution_count":17,"metadata":{"graffitiCellId":"id_vf1wafb","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"F25448093E6340D181FE33A95E9F6FFB","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"tensor([ 2.,  5.,  8., 11., 14., 17.])\n","name":"stdout"}],"source":"def corr1d(X, K):\n    '''\n    @params:\n        X: 输入，形状为 (seq_len,) 的张量\n        K: 卷积核，形状为 (w,) 的张量\n    @return:\n        Y: 输出，形状为 (seq_len - w + 1,) 的张量\n    '''\n    w = K.shape[0] # 卷积窗口宽度\n    Y = torch.zeros((X.shape[0] - w + 1))\n    for i in range(Y.shape[0]): # 滑动窗口\n        Y[i] = (X[i: i + w] * K).sum()\n    return Y\n\nX, K = torch.tensor([0, 1, 2, 3, 4, 5, 6]), torch.tensor([1, 2])\nprint(corr1d(X, K))"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_e67uju2","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"6AA00E61C69A4E42865B78FEC87E757D","mdEditEnable":false},"source":"多输入通道的一维互相关运算也与多输入通道的二维互相关运算类似：在每个通道上，将核与相应的输入做一维互相关运算，并将通道之间的结果相加得到输出结果。下图展示了含 3 个输入通道的一维互相关运算，其中阴影部分为第一个输出元素及其计算所使用的输入和核数组元素：0×1+1×2+1×3+2×4+2×(−1)+3×(−3)=2。\n\n![Image Name](https://cdn.kesci.com/upload/image/q5moaawczv.png?imageView2/0/w/960/h/960)\n"},{"cell_type":"code","execution_count":18,"metadata":{"graffitiCellId":"id_480pc9k","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"4E0F6D6AEB7344F080E9D8B0BFECFAD7","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"tensor([ 2.,  8., 14., 20., 26., 32.])\n","name":"stdout"}],"source":"def corr1d_multi_in(X, K):\n    # 首先沿着X和K的通道维遍历并计算一维互相关结果。然后将所有结果堆叠起来沿第0维累加\n    return torch.stack([corr1d(x, k) for x, k in zip(X, K)]).sum(dim=0)\n    # [corr1d(X[i], K[i]) for i in range(X.shape[0])]\n\nX = torch.tensor([[0, 1, 2, 3, 4, 5, 6],\n              [1, 2, 3, 4, 5, 6, 7],\n              [2, 3, 4, 5, 6, 7, 8]])\nK = torch.tensor([[1, 2], [3, 4], [-1, -3]])\nprint(corr1d_multi_in(X, K))"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_owwaz9l","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"FE1904E0DCC34AEB939DFE0B911985A6","mdEditEnable":false},"source":"由二维互相关运算的定义可知，多输入通道的一维互相关运算可以看作单输入通道的二维互相关运算。如图所示，我们也可以将图中多输入通道的一维互相关运算以等价的单输入通道的二维互相关运算呈现。这里核的高等于输入的高。图中的阴影部分为第一个输出元素及其计算所使用的输入和核数组元素：2×(−1)+3×(−3)+1×3+2×4+0×1+1×2=2。\n\n![Image Name](https://cdn.kesci.com/upload/image/q5moav6ue3.png?imageView2/0/w/960/h/960)\n\n*注：反之仅当二维卷积核的高度等于输入的高度时才成立。*\n\n之前的例子中输出都只有一个通道。我们在[“多输入通道和多输出通道”](https://zh.d2l.ai/chapter_convolutional-neural-networks/channels.html)一节中介绍了如何在二维卷积层中指定多个输出通道。类似地，我们也可以在一维卷积层指定多个输出通道，从而拓展卷积层中的模型参数。\n\n定义多个输出通道的卷积核有利于模型提取更丰富的文本特征，定义多种宽度的卷积核有利于模型提取多个层次的文本特征."},{"attachments":{"image.png":{"image/png":"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"}},"cell_type":"markdown","metadata":{"graffitiCellId":"id_sp8o70s","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"64F1FB72318E45CC8EC2E974216BA59D","mdEditEnable":false},"source":"### 时序最大池化层\n\n类似地，我们有一维池化层。TextCNN 中使用的时序最大池化（max-over-time pooling）层实际上对应一维全局最大池化层：假设输入包含多个通道，各通道由不同时间步上的数值组成，各通道的输出即该通道所有时间步中最大的数值。因此，时序最大池化层的输入在各个通道上的时间步数可以不同。\n\n![Image Name](https://cdn.kesci.com/upload/image/q5mobv3kol.png?imageView2/0/w/960/h/960)\n\n*注：自然语言中还有一些其他的池化操作，可参考这篇[博文](https://blog.csdn.net/malefactor/article/details/51078135)。*\n\n为提升计算性能，我们常常将不同长度的时序样本组成一个小批量，并通过在较短序列后附加特殊字符（如0）令批量中各时序样本长度相同。这些人为添加的特殊字符当然是无意义的。由于时序最大池化的主要目的是抓取时序中最重要的特征，它通常能使模型不受人为添加字符的影响。"},{"cell_type":"code","execution_count":19,"metadata":{"graffitiCellId":"id_3r1xhqh","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"CB9416F229DB46038A3FC9AD670096E3","collapsed":false,"scrolled":false},"outputs":[],"source":"class GlobalMaxPool1d(nn.Module):\n    def __init__(self):\n        super(GlobalMaxPool1d, self).__init__()\n    def forward(self, x):\n        '''\n        @params:\n            x: 输入，形状为 (batch_size, n_channels, seq_len) 的张量\n        @return: 时序最大池化后的结果，形状为 (batch_size, n_channels, 1) 的张量\n        '''\n        return F.max_pool1d(x, kernel_size=x.shape[2]) # kenerl_size=seq_len"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_lhc1gs8","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"D697DE419B87437780D66FB3DD6D6C89","mdEditEnable":false},"source":"### TextCNN 模型\n\nTextCNN 模型主要使用了一维卷积层和时序最大池化层。假设输入的文本序列由 $n$ 个词组成，每个词用 $d$ 维的词向量表示。那么输入样本的宽为 $n$，输入通道数为 $d$。TextCNN 的计算主要分为以下几步。\n\n1. 定义多个一维卷积核，并使用这些卷积核对输入分别做卷积计算。宽度不同的卷积核可能会捕捉到不同个数的相邻词的相关性。\n2. 对输出的所有通道分别做时序最大池化，再将这些通道的池化输出值连结为向量。\n3. 通过全连接层将连结后的向量变换为有关各类别的输出。这一步可以使用丢弃层应对过拟合。\n\n下图用一个例子解释了 TextCNN 的设计。这里的输入是一个有 11 个词的句子，每个词用 6 维词向量表示。因此输入序列的宽为 11，输入通道数为 6。给定 2 个一维卷积核，核宽分别为 2 和 4，输出通道数分别设为 4 和 5。因此，一维卷积计算后，4 个输出通道的宽为 11−2+1=10，而其他 5 个通道的宽为 11−4+1=8。尽管每个通道的宽不同，我们依然可以对各个通道做时序最大池化，并将 9 个通道的池化输出连结成一个 9 维向量。最终，使用全连接将 9 维向量变换为 2 维输出，即正面情感和负面情感的预测。\n\n![Image Name](https://cdn.kesci.com/upload/image/q5modgownf.png?imageView2/0/w/960/h/960)\n\n下面我们来实现 TextCNN 模型。与上一节相比，除了用一维卷积层替换循环神经网络外，这里我们还使用了两个嵌入层，一个的权重固定，另一个则参与训练。"},{"cell_type":"code","execution_count":24,"metadata":{"graffitiCellId":"id_9mqnlf7","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"43E465F855D841EEA2ABD3F0B16F6429","collapsed":false,"scrolled":false},"outputs":[],"source":"class TextCNN(nn.Module):\n    def __init__(self, vocab, embed_size, kernel_sizes, num_channels):\n        '''\n        @params:\n            vocab: 在数据集上创建的词典，用于获取词典大小\n            embed_size: 嵌入维度大小\n            kernel_sizes: 卷积核大小列表\n            num_channels: 卷积通道数列表\n        '''\n        super(TextCNN, self).__init__()\n        self.embedding = nn.Embedding(len(vocab), embed_size) # 参与训练的嵌入层\n        self.constant_embedding = nn.Embedding(len(vocab), embed_size) # 不参与训练的嵌入层\n        \n        self.pool = GlobalMaxPool1d() # 时序最大池化层没有权重，所以可以共用一个实例\n        self.convs = nn.ModuleList()  # 创建多个一维卷积层\n        for c, k in zip(num_channels, kernel_sizes):\n            self.convs.append(nn.Conv1d(in_channels = 2*embed_size, \n                                        out_channels = c, \n                                        kernel_size = k))\n            \n        self.decoder = nn.Linear(sum(num_channels), 2)\n        self.dropout = nn.Dropout(0.5) # 丢弃层用于防止过拟合\n\n    def forward(self, inputs):\n        '''\n        @params:\n            inputs: 词语下标序列，形状为 (batch_size, seq_len) 的整数张量\n        @return:\n            outputs: 对文本情感的预测，形状为 (batch_size, 2) 的张量\n        '''\n        embeddings = torch.cat((\n            self.embedding(inputs), \n            self.constant_embedding(inputs)), dim=2) # (batch_size, seq_len, 2*embed_size)\n        # 根据一维卷积层要求的输入格式，需要将张量进行转置\n        embeddings = embeddings.permute(0, 2, 1) # (batch_size, 2*embed_size, seq_len)\n        \n        encoding = torch.cat([\n            self.pool(F.relu(conv(embeddings))).squeeze(-1) for conv in self.convs], dim=1)\n        # encoding = []\n        # for conv in self.convs:\n        #     out = conv(embeddings) # (batch_size, out_channels, seq_len-kernel_size+1)\n        #     out = self.pool(F.relu(out)) # (batch_size, out_channels, 1)\n        #     encoding.append(out.squeeze(-1)) # (batch_size, out_channels)\n        # encoding = torch.cat(encoding) # (batch_size, out_channels_sum)\n        \n        # 应用丢弃法后使用全连接层得到输出\n        outputs = self.decoder(self.dropout(encoding))\n        return outputs\n\nembed_size, kernel_sizes, nums_channels = 100, [3, 4, 5], [100, 100, 100]\nnet = TextCNN(vocab, embed_size, kernel_sizes, nums_channels)"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_leupmp8","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"374844FBE56B43668639A9C07D0E2DD0","mdEditEnable":false},"source":"### 训练并评价模型"},{"cell_type":"code","execution_count":26,"metadata":{"graffitiCellId":"id_g74v4mq","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"BC1674BE51704FBA9F46925EE338B813","collapsed":false,"scrolled":false},"outputs":[{"output_type":"stream","text":"training on  cpu\nepoch 1, loss 0.2317, train acc 0.956, test acc 0.782, time 374.0 sec\nepoch 2, loss 0.0527, train acc 0.973, test acc 0.780, time 372.5 sec\nepoch 3, loss 0.0211, train acc 0.981, test acc 0.783, time 375.3 sec\nepoch 4, loss 0.0119, train acc 0.985, test acc 0.788, time 370.7 sec\nepoch 5, loss 0.0078, train acc 0.989, test acc 0.791, time 370.8 sec\n","name":"stdout"}],"source":"lr, num_epochs = 0.001, 5\noptimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), lr=lr)\nloss = nn.CrossEntropyLoss()\ntrain(train_iter, test_iter, net, loss, optimizer, device, num_epochs)"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_b5cbyuk","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"8BEB86488C464EB09629F94A5198DCDB","mdEditEnable":false},"source":"```\ntraining on  cuda\nepoch 1, loss 0.6314, train acc 0.666, test acc 0.803, time 15.9 sec\nepoch 2, loss 0.2416, train acc 0.766, test acc 0.807, time 15.9 sec\nepoch 3, loss 0.1330, train acc 0.821, test acc 0.849, time 15.9 sec\nepoch 4, loss 0.0825, train acc 0.858, test acc 0.860, time 16.0 sec\nepoch 5, loss 0.0494, train acc 0.898, test acc 0.865, time 15.9 sec\n```"},{"cell_type":"code","execution_count":8,"metadata":{"graffitiCellId":"id_me4atgv","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"4817955A29B1426BA9AF6B9493EC83F0","collapsed":false,"scrolled":false},"outputs":[],"source":"predict_sentiment(net, vocab, ['this', 'movie', 'is', 'so', 'great'])"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_ib2b1mq","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"F2B54C724B3B4B249AE7985638ACF8B3","mdEditEnable":false},"source":"```\n'positive'\n```"},{"cell_type":"code","execution_count":11,"metadata":{"graffitiCellId":"id_6qea9rq","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"EF6C2C490A2C49DC8F49794FB5BCD7ED","collapsed":false,"scrolled":false},"outputs":[],"source":"predict_sentiment(net, vocab, ['this', 'movie', 'is', 'so', 'bad'])"},{"cell_type":"markdown","metadata":{"graffitiCellId":"id_ez92ken","jupyter":{},"tags":[],"slideshow":{"slide_type":"slide"},"id":"7861B9EE96B94CFC946336A441DED112","mdEditEnable":false},"source":"```\n'negative'\n```"}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.3","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}